package com.CRApp.controller;

import com.CRApp.pojo.Order;
import com.CRApp.pojo.Result;
import com.CRApp.service.OrderService;
import com.CRApp.utils.ThreadLocalUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

/**
 * 订单控制器
 * 提供订单相关的RESTful API
 */
@RestController
@RequestMapping("/order")
@Validated
@CrossOrigin
public class OrderController {
    
    private static final Logger logger = LoggerFactory.getLogger(OrderController.class);
    
    @Autowired
    private OrderService orderService;
    
    /**
     * 获取当前登录用户ID
     * @return 用户ID，未登录返回null
     */
    private Integer getCurrentUserId() {
        Map<String, Object> userInfo = ThreadLocalUtil.get();
        return userInfo != null ? (Integer) userInfo.get("id") : null;
    }
    
    /**
     * 订单根路径（有斜杠）
     * GET /order/ - 默认重定向到订单列表
     * @return 订单列表
     */
    @GetMapping("/")
    public Result<List<Order>> getOrdersWithSlash() {
        logger.info("收到订单根路径请求（带斜杠），重定向到订单列表");
        return getUserOrders();
    }
    
    /**
     * 订单根路径（无斜杠）
     * GET /order - 默认重定向到订单列表
     * @return 订单列表
     */
    @GetMapping("")
    public Result<List<Order>> getOrdersWithoutSlash() {
        logger.info("收到订单根路径请求（不带斜杠），重定向到订单列表");
        return getUserOrders();
    }
    
    /**
     * 创建订单
     * POST /order/create - 创建新订单
     * @param params 订单参数
     * @return 创建结果，包含订单信息
     */
    @PostMapping("/create")
    public Result<Order> createOrder(@RequestBody Map<String, Object> params) {
        logger.info("收到创建订单请求: {}", params);
        
        // 获取当前登录用户ID
        Integer userId = getCurrentUserId();
        if (userId == null) {
            return Result.error("创建失败：用户未登录");
        }
        
        try {
            Order order = orderService.createOrder(params, userId);
            if (order != null) {
                return Result.success(order);
            } else {
                return Result.error("创建失败：请检查参数是否完整");
            }
        } catch (Exception e) {
            logger.error("创建订单失败", e);
            return Result.error("创建失败：" + e.getMessage());
        }
    }
    
    /**
     * 批量创建订单
     * POST /order/batch-create - 同时结算多个商品创建多个订单
     * @param paramsList 订单参数列表，每个元素包含一个商品的订单信息
     * @return 创建结果，包含创建的订单列表
     */
    @PostMapping("/batch-create")
    public Result<List<Order>> batchCreateOrders(@RequestBody List<Map<String, Object>> paramsList) {
        logger.info("收到批量创建订单请求，商品数量: {}", paramsList.size());
        
        // 获取当前登录用户ID
        Integer userId = getCurrentUserId();
        if (userId == null) {
            return Result.error("创建失败：用户未登录");
        }
        
        // 检查参数列表
        if (paramsList.isEmpty()) {
            return Result.error("创建失败：订单列表不能为空");
        }
        
        try {
            List<Order> orders = orderService.batchCreateOrders(paramsList, userId);
            if (orders != null && !orders.isEmpty()) {
                return Result.success(orders);
            } else {
                return Result.error("创建失败：请检查参数是否完整");
            }
        } catch (Exception e) {
            logger.error("批量创建订单失败", e);
            return Result.error("创建失败：" + e.getMessage());
        }
    }
    
    /**
     * 获取用户订单列表
     * GET /order/list - 获取当前用户的所有订单
     * @return 订单列表
     */
    @GetMapping("/list")
    public Result<List<Order>> getUserOrders() {
        logger.info("收到获取订单列表请求");
        
        // 获取当前登录用户ID
        Integer userId = getCurrentUserId();
        if (userId == null) {
            return Result.error("查询失败：用户未登录");
        }
        
        try {
            List<Order> orders = orderService.getUserOrders(userId);
            return Result.success(orders);
        } catch (Exception e) {
            logger.error("获取订单列表失败", e);
            return Result.error("查询失败：" + e.getMessage());
        }
    }
    
    /**
     * 获取订单详情
     * GET /order/detail/{orderNumber} - 获取指定编号的订单详情
     * @param orderNumber 订单编号
     * @return 订单详情
     */
    @GetMapping("/detail/{orderNumber}")
    public Result<Order> getOrderDetail(@PathVariable String orderNumber) {
        logger.info("收到获取订单详情请求，订单编号：{}", orderNumber);
        
        // 获取当前登录用户ID
        Integer userId = getCurrentUserId();
        if (userId == null) {
            return Result.error("查询失败：用户未登录");
        }
        
        try {
            Order order = orderService.getOrderDetail(orderNumber, userId);
            if (order != null) {
                return Result.success(order);
            } else {
                return Result.error("查询失败：订单不存在或无权查看");
            }
        } catch (Exception e) {
            logger.error("获取订单详情失败", e);
            return Result.error("查询失败：" + e.getMessage());
        }
    }
    
    /**
     * 更新订单状态
     * PUT /order/status/{orderNumber} - 更新指定订单的状态
     * @param orderNumber 订单编号
     * @param params 更新参数，包含status字段
     * @return 更新结果
     */
    @PutMapping("/status/{orderNumber}")
    public Result<?> updateOrderStatus(@PathVariable String orderNumber, @RequestBody Map<String, String> params) {
        String status = params.get("status");
        logger.info("收到更新订单状态请求，订单编号：{}，新状态：{}", orderNumber, status);
        
        if (status == null || status.isEmpty()) {
            return Result.error("更新失败：状态参数不能为空");
        }
        
        // 获取当前登录用户ID
        Integer userId = getCurrentUserId();
        if (userId == null) {
            return Result.error("更新失败：用户未登录");
        }
        
        try {
            boolean success = orderService.updateOrderStatus(orderNumber, status, userId);
            return success ? Result.success() : Result.error("更新失败：订单不存在或无权操作");
        } catch (Exception e) {
            logger.error("更新订单状态失败", e);
            return Result.error("更新失败：" + e.getMessage());
        }
    }
    
    /**
     * 取消订单
     * PUT /order/cancel/{orderNumber} - 取消指定订单
     * @param orderNumber 订单编号
     * @return 取消结果
     */
    @PutMapping("/cancel/{orderNumber}")
    public Result<?> cancelOrder(@PathVariable String orderNumber) {
        logger.info("收到取消订单请求，订单编号：{}", orderNumber);
        
        // 获取当前登录用户ID
        Integer userId = getCurrentUserId();
        if (userId == null) {
            return Result.error("取消失败：用户未登录");
        }
        
        try {
            boolean success = orderService.cancelOrder(orderNumber, userId);
            return success ? Result.success() : Result.error("取消失败：订单不存在、无权操作或状态不允许取消");
        } catch (Exception e) {
            logger.error("取消订单失败", e);
            return Result.error("取消失败：" + e.getMessage());
        }
    }
    
    /**
     * 删除订单
     * DELETE /order/{orderNumber} - 删除指定订单
     * @param orderNumber 订单编号
     * @return 删除结果
     */
    @DeleteMapping("/{orderNumber}")
    public Result<?> deleteOrder(@PathVariable String orderNumber) {
        logger.info("收到删除订单请求，订单编号：{}", orderNumber);
        
        // 获取当前登录用户ID
        Integer userId = getCurrentUserId();
        if (userId == null) {
            return Result.error("删除失败：用户未登录");
        }
        
        try {
            boolean success = orderService.deleteOrder(orderNumber, userId);
            return success ? Result.success() : Result.error("删除失败：订单不存在或无权操作");
        } catch (Exception e) {
            logger.error("删除订单失败", e);
            return Result.error("删除失败：" + e.getMessage());
        }
    }
} 